home *** CD-ROM | disk | FTP | other *** search
/ Mac Power 1997 December / MACPOWER-1997-12.ISO.7z / MACPOWER-1997-12.ISO / AMUG / PROGRAMMING / Raven 1.2.sit / Raven 1.2 / Source / Foundation / OS / ZDialogUtils.cpp < prev    next >
Text File  |  1997-09-05  |  21KB  |  804 lines
  1. /*
  2.  *  File:       ZDialogUtils.h
  3.  *  Summary:       Handy dialog manager related routines.
  4.  *  Written by: Jesse Jones
  5.  *
  6.  *  Copyright ｩ 1996-1997 Jesse Jones. 
  7.  *    For conditions of distribution and use, see copyright notice in ZTypes.h  
  8.  *
  9.  *  Change History (most recent first):    
  10.  *
  11.  *         <4>     8/05/97    JDJ        DoNote, DoCaution, and DoStop use StandardAlert in OS 8.
  12.  *                                    Added DoSave and DoRevert.
  13.  *         <3>     8/01/97    JDJ        DefaultFilterProc uses IsCommandPeriod.
  14.  *         <2>     1/09/96    JDJ        DoNote, DoCaution, and DoStop use the Notification
  15.  *                                    Manager if the app is in the background.
  16.  *         <1>     5/06/96    JDJ        Created
  17.  */
  18.  
  19. #include <ZDialogUtils.h>
  20.  
  21. #include <Appearance.h>
  22. #include <CType.h>
  23. #include <Palettes.h>
  24. #include <Scrap.h>
  25.  
  26. #include <ZConstants.h>
  27. #include <ZDebug.h>
  28. #include <ZGestalt.h>
  29. #include <ZMiscUtils.h>
  30. #include <ZNotify.h>
  31. #include <ZProcess.h>
  32. #include <ZStringUtils.h>
  33.  
  34.  
  35. // ===================================================================================
  36. //    Internal Functions
  37. // ===================================================================================
  38.  
  39. //---------------------------------------------------------------
  40. //
  41. // IsAColorPort
  42. //
  43. //---------------------------------------------------------------
  44. static bool IsAColorPort(GrafPtr port = nil)
  45. {
  46.     if (port == nil)
  47.         GetPort(&port);
  48.         
  49.     return ((((CGrafPtr) port)->portVersion & (short) 0xC000)) == (short) 0xC000;
  50. } 
  51.  
  52.  
  53. //---------------------------------------------------------------
  54. //
  55. // GetGrayColor
  56. //
  57. //---------------------------------------------------------------
  58. static RGBColor GetGrayColor(GDHandle device = nil)
  59. {
  60.     if (device == nil) {
  61.         device = GetGDevice();
  62.         ASSERT(device != nil);
  63.     }
  64.         
  65.     RGBColor back = {0, 0, 0};
  66.     RGBColor gray = {65535, 65535, 65535};
  67.     
  68.     (void) GetGray(device, &back, &gray);
  69.     
  70.     return gray;
  71. }
  72.  
  73.  
  74. //---------------------------------------------------------------
  75. //
  76. // IsPushButton
  77. //
  78. //---------------------------------------------------------------
  79. static bool IsPushButton(DialogPtr dialog, short item)
  80. {
  81.     ASSERT(dialog != nil);
  82.     
  83.     bool isBtn = false;
  84.     
  85.     if (item >= 1 && item <= CountDITL(dialog)) {
  86.         short    itemType;
  87.         Handle    itemHandle;
  88.         Rect    itemRect;
  89.     
  90.         GetDialogItem(dialog, item, &itemType, &itemHandle, &itemRect);
  91.         if (itemType > itemDisable)
  92.              itemType -= itemDisable;
  93.              
  94.         isBtn = itemType == ctrlItem + btnCtrl;
  95.     }
  96.         
  97.     return isBtn;
  98. }
  99.  
  100.  
  101. //---------------------------------------------------------------
  102. //
  103. // DashedLineProc    
  104. //
  105. //---------------------------------------------------------------
  106. static UserItemUPP sDashLineProc = nil;
  107.  
  108. static pascal void DashedLineProc(DialogPtr dialog, short item)
  109. {
  110.     TRect bounds = GetItemBounds(dialog, item);
  111.     
  112.     Pattern pat;
  113.     GetIndPattern(&pat, sysPatListID, 4);
  114.     FillRect(bounds, &pat);
  115. }
  116.  
  117.  
  118. //---------------------------------------------------------------
  119. //
  120. // DrawPictureAt
  121. //
  122. // Draws specified picture at specified point without scaling.
  123. //
  124. //---------------------------------------------------------------
  125. static void DrawPictureAt(PicHandle picHand, TPoint dstPoint)
  126. {
  127.     TRect dstRect;
  128.  
  129.     dstRect[topLeft] = dstPoint;
  130.     dstRect[botRight] = dstPoint + TRect((**picHand).picFrame).GetSize();
  131.  
  132.     DrawPicture(picHand, dstRect);
  133. }
  134.  
  135.  
  136. //---------------------------------------------------------------
  137. //
  138. // DrawPictProc    
  139. //
  140. // Draws a picture in a user item. If the picture is smaller than 
  141. // the user item it is centered within the user item.
  142. //
  143. //---------------------------------------------------------------
  144. static UserItemUPP     sDrawPictProc = nil;
  145. static PicHandle*    sPict = nil;
  146.  
  147. static pascal void DrawPictProc(DialogPtr dialog, short item)
  148. {
  149.     TRect itemRect = GetItemBounds(dialog, item);
  150.     TRect dstRect  = itemRect;
  151.     
  152.     EraseRect(itemRect);
  153.     if (sPict!= nil && *sPict != nil) {
  154.         TRect picFrame = (***sPict).picFrame;
  155.         TPoint delta = dstRect.GetSize() - picFrame.GetSize();
  156.         dstRect.Inset((short) (delta.h/2), (short) (delta.v/2));
  157.         
  158.         DrawPictureAt(*sPict, dstRect[topLeft]);
  159.         
  160.     } else {
  161.         dstRect.Inset(1, 1);
  162.         FillRect(dstRect, &qd.gray);
  163.     }
  164.     
  165.     dstRect.Inset(-1, -1);
  166.     FrameRect(dstRect);    
  167. }
  168.  
  169.  
  170. //---------------------------------------------------------------
  171. //
  172. // DrawDefaultOutline
  173. //
  174. //---------------------------------------------------------------
  175. static void DrawDefaultOutline(DialogPtr dptr)
  176. {
  177.     short item = GetDialogDefaultItem(dptr);
  178.     
  179.     if (item > 0 && (GetItemType(dptr, item) & (ctrlItem+btnCtrl)) != 0) {
  180.         PenState oldState;
  181.         GetPenState(&oldState);
  182.         
  183.         PenNormal();
  184.         PenSize(3, 3);
  185.         PenMode(srcCopy);
  186.  
  187.         TRect bounds = GetItemBounds(dptr, item);
  188.         bounds.Inset(-4, -4);
  189.         
  190.         if (!ItemIsEnabled(dptr, item))
  191.             if (IsAColorPort())
  192.                 ::RGBForeColor(&GetGrayColor());
  193.             else
  194.                 PenPat(&qd.gray);
  195.         
  196.         short buttonOval = (short) (2 + (bounds.bottom - bounds.top)/2);
  197.         FrameRoundRect(bounds, buttonOval, buttonOval);
  198.             
  199.         SetPenState(&oldState);
  200.     }
  201. }  
  202.  
  203. #pragma mark -
  204.  
  205. //---------------------------------------------------------------
  206. //
  207. // DefaultFilterProc
  208. //
  209. //---------------------------------------------------------------
  210. pascal Boolean DefaultFilterProc(DialogPtr dptr, EventRecord* event, short* item)
  211. {
  212.     bool handled = false;
  213.     
  214.     GrafPtr oldPort;
  215.     GetPort(&oldPort);
  216.     SetPort(dptr);
  217.     
  218.     // Set the cursor to the ibeam if we're over an editBox.
  219.     Point mouse;
  220.     GetMouse(&mouse);
  221.     short itemType = statText;
  222.     short itemNum = (short) (FindDialogItem(dptr, mouse) + 1);
  223.     if (itemNum > 0)
  224.         itemType = GetItemType(dptr, itemNum);
  225.     SetCursor(itemType == editText ? *GetCursor(iBeamCursor) : &qd.arrow);
  226.  
  227.     short defaultItem = GetDialogDefaultItem(dptr);
  228.     short cancelItem  = 2;                                // GetDialogCancelItem isn't working...
  229.         
  230.     // If it's an update event draw an outline around the default button.
  231.     if (event->what == updateEvt && defaultItem > 0)
  232.         if ((DialogPtr) event->message == dptr)
  233.             DrawDefaultOutline(dptr);
  234.  
  235.     // Handle keystrokes.
  236.     if (event->what == keyDown) {
  237.         char ch   = (char) (event->message & charCodeMask);
  238.         short key = (short) ((event->message & keyCodeMask) >> 8);
  239.         
  240.         bool defaultEnabled = IsPushButton(dptr, defaultItem) && ItemIsEnabled(dptr, defaultItem);
  241.         bool cancelEnabled  = IsPushButton(dptr, cancelItem) && ItemIsEnabled(dptr, cancelItem);
  242.         
  243.         // Map F2, F3, and F4 function keys to cmd X, C, and V.
  244.         switch (key) {
  245.             case kF2Key:
  246.                 event->modifiers |= cmdKey;
  247.                 key = 'x';
  248.                 break;
  249.             
  250.             case kF3Key:
  251.                 event->modifiers |= cmdKey;
  252.                 key = 'c';
  253.                 break;
  254.             
  255.             case kF4Key:
  256.                 event->modifiers |= cmdKey;
  257.                 key = 'v';
  258.                 break;
  259.         }            
  260.         
  261.         // Handle cmd X, C, and V.
  262.         if ((event->modifiers & cmdKey) != 0) {
  263.             switch (toupper(ch)) {
  264.                 case 'X':
  265.                     ZeroScrap();
  266.                     DialogCut(dptr);                // Note that these do nothing if the dialog has no edit box.
  267.                     if (TEToScrap() != noErr && !gMonkeyLives)
  268.                         SysBeep(1);
  269.                     handled = true;
  270.                     break;
  271.                                         
  272.                 case 'C':
  273.                     ZeroScrap();
  274.                     DialogCopy(dptr);
  275.                     if (TEToScrap() != noErr && !gMonkeyLives)
  276.                         SysBeep(1);
  277.                     handled = true;
  278.                     break;
  279.                                         
  280.                 case 'V':
  281.                     if (TEFromScrap() == noErr)
  282.                         DialogPaste(dptr);
  283.                     else if (!gMonkeyLives)
  284.                         SysBeep(1);
  285.                     handled = true;
  286.                     break;
  287.             }    
  288.             
  289.         // Handle return and escape keys.
  290.         } else if ((ch == kReturnChar || ch == kEnterChar) && defaultEnabled) {
  291.             *item = defaultItem;
  292.             FlashButton(dptr, *item);
  293.             handled = true;
  294.         
  295.         } else if ((ch == kTildeChar || key == kEscapeKey) && cancelEnabled) { 
  296.             *item = cancelItem;
  297.             FlashButton(dptr, *item);
  298.             handled = true;
  299.         }
  300.         
  301.         // Handle command-period.
  302.         if (!handled && cancelEnabled && IsCommandPeriod(*event)) {
  303.             *item = cancelItem;
  304.             FlashButton(dptr, *item);
  305.             handled = true;
  306.         }
  307.     }
  308.     
  309.     SetPort(oldPort);
  310.  
  311.     return handled;
  312. }
  313.  
  314. static ModalFilterProcPtr     sFilters[8] = {DefaultFilterProc};
  315. static int                    sNumFilters = 1;
  316.  
  317. //---------------------------------------------------------------
  318. //
  319. // DefaultFilter
  320. //
  321. //---------------------------------------------------------------
  322. pascal Boolean DefaultFilter(DialogPtr dptr, EventRecord* event, short* item)
  323. {
  324.     bool handled = false;
  325.     
  326.     GrafPtr oPort;
  327.     GetPort(&oPort);
  328.     
  329.     for (int index = 0; index < sNumFilters && !handled; index++)
  330.         handled = (sFilters[index])(dptr, event, item);
  331.         
  332.     SetPort(oPort);
  333.     
  334.     return handled;
  335. }
  336.  
  337.  
  338. //---------------------------------------------------------------
  339. //
  340. // SaveChangesFilter
  341. //
  342. //---------------------------------------------------------------
  343. pascal Boolean SaveChangesFilter(DialogPtr dptr, EventRecord* event, short* item)
  344. {
  345.     bool handled = false;
  346.         
  347.     if (event->what == keyDown) {
  348.         char ch = (char) toupper((char) (event->message & charCodeMask));
  349.         if (ch == 'S') { 
  350.             *item = 1;
  351.             handled = true;
  352.         } else if (ch == 'D') { 
  353.             *item = 3;
  354.             handled = true;
  355.         }
  356.         
  357.         if (handled) 
  358.             FlashButton(dptr, *item);
  359.     }
  360.     
  361.     if (!handled)
  362.         handled = DefaultFilter(dptr, event, item);
  363.     
  364.     return handled;
  365. }
  366.  
  367. //---------------------------------------------------------------
  368. //
  369. // DefaultYDFilter
  370. //
  371. //---------------------------------------------------------------
  372. pascal Boolean DefaultYDFilter(DialogPtr dptr, EventRecord* event, short* item, void* myData)
  373. {
  374.     #pragma unused(myData)
  375.     
  376.     bool handled = false;                    // Note that returning true dismisses the dialog.
  377.     
  378.     GrafPtr oPort;
  379.     GetPort(&oPort);
  380.     
  381.     for (int index = 0; index < sNumFilters && !handled; index++)
  382.         handled = (sFilters[index])(dptr, event, item);
  383.     
  384.     SetPort(oPort);
  385.     
  386.     return handled;
  387. }
  388.  
  389.  
  390. //---------------------------------------------------------------
  391. //
  392. // AddDialogFilter
  393. //
  394. //---------------------------------------------------------------
  395. void AddDialogFilter(ModalFilterProcPtr filter)
  396. {
  397.     ASSERT(filter != nil);
  398.     ASSERT(sNumFilters < 8);
  399.     
  400.     sFilters[sNumFilters++] = filter;
  401. }
  402.  
  403. #pragma mark -
  404.  
  405. //---------------------------------------------------------------
  406. //
  407. // DoAlert
  408. //
  409. //---------------------------------------------------------------
  410. short DoAlert(ResID id, ModalFilterProcPtr filter)
  411. {
  412.     RoutineDescriptor desc = BUILD_ROUTINE_DESCRIPTOR(uppModalFilterProcInfo, filter);
  413.     ModalFilterUPP theFilter = (ModalFilterUPP) &desc;
  414.  
  415.     InitCursor();
  416.     short item = Alert(id, theFilter);
  417.     DisposeRoutineDescriptor((UniversalProcPtr) theFilter);
  418.     
  419.     return item;
  420. }
  421.  
  422.  
  423. //---------------------------------------------------------------
  424. //
  425. // DoStandardAlert
  426. //
  427. //---------------------------------------------------------------
  428. static short DoStandardAlert(AlertType type, const string& errorStr, const string& supplementalStr, ResID id, ModalFilterProcPtr filter)
  429. {
  430.     ASSERT(filter != nil);
  431.      
  432.     short item = ok;
  433.     
  434.     string text = errorStr + "¥r¥r" + supplementalStr;
  435.  
  436. #if !DRAG_AND_DROP_APP                        // TNotify and StateBroadcaster are overkill for a simple d&d app
  437.     if (!UProcess::InFront()) {
  438.         TNotify* note = new TNotify(text);
  439.         note->Post();
  440.     
  441.     } else 
  442. #endif
  443.     {
  444.         InitCursor();
  445.  
  446.         RoutineDescriptor desc = BUILD_ROUTINE_DESCRIPTOR(uppModalFilterProcInfo, filter);
  447.         ModalFilterUPP theFilter = (ModalFilterUPP) &desc;
  448.  
  449.         if (UGestalt::hasAppearanceMgr) {
  450.             AlertStdAlertParamRec params;
  451.             params.movable       = true;
  452.             params.helpButton    = false;
  453.             params.filterProc    = theFilter;
  454.             params.defaultText   = (StringPtr) -1L;        // use default (ie "OK")
  455.             params.cancelText    = nil;
  456.             params.otherText     = nil;
  457.             params.defaultButton = 1;
  458.             params.cancelButton  = 0;
  459.             params.position      = kWindowAlertPositionParentWindowScreen;
  460.     
  461.             OSErr err = StandardAlert(type, StrToPStr(errorStr), StrToPStr(supplementalStr), ¶ms, &item);
  462.             ASSERT(err == noErr);                        // seems kind of pointless to throw
  463.     
  464.         } else {
  465.             ParamText(StrToPStr(text), "¥p", "¥p", "¥p");
  466.  
  467.             if (type == kAlertStopAlert)
  468.                 item = StopAlert(id, theFilter);
  469.                 
  470.             else if (type == kAlertNoteAlert)
  471.                 item = NoteAlert(id, theFilter);
  472.                 
  473.             else 
  474.                 item = CautionAlert(id, theFilter);
  475.         }
  476.         
  477.         DisposeRoutineDescriptor((UniversalProcPtr) theFilter);
  478.     }
  479.         
  480.     return item;
  481. }
  482.  
  483.  
  484. //---------------------------------------------------------------
  485. //
  486. // DoNote
  487. //
  488. //---------------------------------------------------------------
  489. short DoNote(const string& errorStr, const string& supplementalStr, ResID id, ModalFilterProcPtr filter)
  490. {
  491.     short item = DoStandardAlert(kAlertNoteAlert, errorStr, supplementalStr, id, filter);
  492.         
  493.     return item;
  494. }
  495.  
  496.  
  497. //---------------------------------------------------------------
  498. //
  499. // DoCaution
  500. //
  501. //---------------------------------------------------------------
  502. short DoCaution(const string& errorStr, const string& supplementalStr, ResID id, ModalFilterProcPtr filter)
  503. {
  504.     short item = DoStandardAlert(kAlertCautionAlert, errorStr, supplementalStr, id, filter);
  505.         
  506.     return item;
  507. }
  508.  
  509.  
  510. //---------------------------------------------------------------
  511. //
  512. // DoStop
  513. //
  514. //---------------------------------------------------------------
  515. short DoStop(const string& errorStr, const string& supplementalStr, ResID id, ModalFilterProcPtr filter)
  516. {
  517.     short item = DoStandardAlert(kAlertStopAlert, errorStr, supplementalStr, id, filter);
  518.         
  519.     return item;
  520. }
  521.  
  522.  
  523. //---------------------------------------------------------------
  524. //
  525. // DoSave
  526. //
  527. //---------------------------------------------------------------
  528. short DoSave(const string& fileName, ModalFilterProcPtr filter)
  529. {
  530.     ASSERT(filter != nil);
  531.      
  532.     short item = kSaveBtn;
  533.     
  534.     InitCursor();
  535.  
  536.     RoutineDescriptor desc = BUILD_ROUTINE_DESCRIPTOR(uppModalFilterProcInfo, filter);
  537.     ModalFilterUPP theFilter = (ModalFilterUPP) &desc;
  538.  
  539.     if (UGestalt::hasAppearanceMgr) {
  540.         AlertStdAlertParamRec params;
  541.         params.movable       = true;
  542.         params.helpButton    = false;
  543.         params.filterProc    = theFilter;
  544.         params.defaultText   = StrToPStr(LoadRavenString("Save (Button)"));
  545.         params.cancelText    = StrToPStr(LoadRavenString("Cancel (Button)"));
  546.         params.otherText     = StrToPStr(LoadRavenString("Don't Save (Button)"));
  547.         params.defaultButton = kSaveBtn;
  548.         params.cancelButton  = kCancelBtn;
  549.         params.position      = kWindowAlertPositionParentWindowScreen;
  550.  
  551.         string errorStr = LoadRavenString("File ﾒ") + fileName + LoadRavenString("ﾓ not saved.");
  552.         string supplementalStr = LoadRavenString("Changes made to the file ﾒ") + fileName + LoadRavenString("ﾓ will be discarded if this file is not saved. Do you want to save changes to this file before closing it?");
  553.         
  554.         OSErr err = StandardAlert(kAlertCautionAlert, StrToPStr(errorStr), StrToPStr(supplementalStr), ¶ms, &item);
  555.         ASSERT(err == noErr);                        // seems kind of pointless to throw
  556.  
  557.     } else {
  558.         ParamText(StrToPStr(fileName), "¥p", "¥p", "¥p");
  559.  
  560.         item = CautionAlert(kSaveChangesAlert, theFilter);
  561.     }
  562.     
  563.     DisposeRoutineDescriptor((UniversalProcPtr) theFilter);
  564.         
  565.     return item;
  566. }
  567.  
  568.  
  569. //---------------------------------------------------------------
  570. //
  571. // DoRevert
  572. //
  573. //---------------------------------------------------------------
  574. bool DoRevert(const string& fileName, ModalFilterProcPtr filter)
  575. {
  576.     ASSERT(filter != nil);
  577.      
  578.     short item = cancel;
  579.     
  580.     InitCursor();
  581.  
  582.     RoutineDescriptor desc = BUILD_ROUTINE_DESCRIPTOR(uppModalFilterProcInfo, filter);
  583.     ModalFilterUPP theFilter = (ModalFilterUPP) &desc;
  584.  
  585.     if (UGestalt::hasAppearanceMgr) {
  586.         AlertStdAlertParamRec params;
  587.         params.movable       = true;
  588.         params.helpButton    = false; 
  589.         params.filterProc    = theFilter;
  590.         params.defaultText   = (StringPtr) -1L;        // use default (ie "OK")
  591.         params.cancelText    = (StringPtr) -1L;        // use default (ie "Cancel")
  592.         params.otherText     = nil; 
  593.         params.defaultButton = cancel;
  594.         params.cancelButton  = 0;
  595.         params.position      = kWindowAlertPositionParentWindowScreen;
  596.  
  597.         string errorStr = LoadRavenString("Revert changes to file ﾒ") + fileName + LoadRavenString("ﾓ.");
  598.         string supplementalStr = LoadRavenString("Reverting file ﾒ") + fileName + LoadRavenString("ﾓ will discard all changes made to this file since you last saved it. Do you want to discard all changes to this file?");
  599.         
  600.         OSErr err = StandardAlert(kAlertCautionAlert, StrToPStr(errorStr), StrToPStr(supplementalStr), ¶ms, &item);
  601.         ASSERT(err == noErr);                        // seems kind of pointless to throw
  602.  
  603.     } else {
  604.         ParamText(StrToPStr(fileName), "¥p", "¥p", "¥p");
  605.  
  606.         item = CautionAlert(kConfirmRevertAlert, theFilter);
  607.     }
  608.     
  609.     DisposeRoutineDescriptor((UniversalProcPtr) theFilter);
  610.         
  611.     return item == ok;
  612. }
  613.  
  614. #pragma mark -
  615.  
  616. //---------------------------------------------------------------
  617. //
  618. // GetItemBounds
  619. //
  620. //---------------------------------------------------------------
  621. TRect GetItemBounds(DialogPtr dialog, short item)
  622. {
  623.     short    itemType;
  624.     Handle    itemHandle;
  625.     Rect    itemRect;
  626.  
  627.     GetDialogItem(dialog, item, &itemType, &itemHandle, &itemRect);
  628.     
  629.     return itemRect;
  630. }
  631.  
  632.  
  633. //---------------------------------------------------------------
  634. //
  635. // GetItemType
  636. //
  637. //---------------------------------------------------------------
  638. short GetItemType(DialogPtr dialog, short item)
  639. {
  640.     short    itemType;
  641.     Handle    itemHandle;
  642.     Rect    itemRect;
  643.  
  644.     GetDialogItem(dialog, item, &itemType, &itemHandle, &itemRect);
  645.     
  646.     return itemType;
  647. }
  648.  
  649.  
  650. //---------------------------------------------------------------
  651. //
  652. // ItemIsEnabled
  653. //
  654. //---------------------------------------------------------------
  655. bool ItemIsEnabled(DialogPtr dialog, short item)
  656. {
  657.     short    itemType;
  658.     Handle    itemHandle;
  659.     Rect    itemRect;
  660.  
  661.     GetDialogItem(dialog, item, &itemType, &itemHandle, &itemRect);
  662.     
  663.     return (itemType & itemDisable) == false;
  664. }
  665.  
  666.  
  667. //---------------------------------------------------------------
  668. //
  669. // GetControl
  670. //
  671. //---------------------------------------------------------------
  672. ControlHandle GetControl(DialogPtr dialog, short item)
  673. {
  674.     ASSERT(dialog != nil);
  675.     ASSERT(item >= 1 && item <= CountDITL(dialog));
  676.  
  677.     short    itemType;
  678.     Handle    itemHandle;
  679.     Rect    itemRect;
  680.  
  681.     GetDialogItem(dialog, item, &itemType, &itemHandle, &itemRect);
  682.     if (itemType > itemDisable)
  683.          itemType -= itemDisable;
  684.     ASSERT(itemType >= ctrlItem + btnCtrl && itemType <= ctrlItem + resCtrl);
  685.     
  686.     return (ControlHandle) itemHandle;
  687. }
  688.  
  689.  
  690. //---------------------------------------------------------------
  691. //
  692. // GetDStr
  693. //
  694. //---------------------------------------------------------------
  695. string GetDStr(DialogPtr dialog, short item)
  696. {
  697.     ASSERT(dialog != nil);
  698.     ASSERT(item >= 1 && item <= CountDITL(dialog));
  699.  
  700.     short    itemType;
  701.     Handle    itemHandle;
  702.     Rect    itemRect;
  703.     Str255    itemString;
  704.  
  705.     GetDialogItem(dialog, item, &itemType, &itemHandle, &itemRect);
  706.     if (itemType > itemDisable)
  707.          itemType -= itemDisable;
  708.     ASSERT(itemType == statText || itemType == editText);
  709.     GetDialogItemText(itemHandle, itemString);
  710.     
  711.     return PStrToStr(itemString);
  712. }
  713.  
  714. #pragma mark -
  715.  
  716. //---------------------------------------------------------------
  717. //
  718. // SetUserProc
  719. //
  720. //---------------------------------------------------------------
  721. void SetUserProc(DialogPtr dialog, short item, UserItemUPP userProc)
  722. {
  723.     short    itemType;
  724.     Handle    itemHandle;
  725.     Rect    itemRect;
  726.  
  727.     GetDialogItem(dialog, item, &itemType, &itemHandle, &itemRect);
  728.     ASSERT(itemType == userItem || itemType == userItem+itemDisable);
  729.     SetDialogItem(dialog, item, itemType, (Handle) userProc, &itemRect);
  730. }
  731.  
  732.  
  733. //---------------------------------------------------------------
  734. //
  735. // SetDashedLineProc
  736. //
  737. //---------------------------------------------------------------
  738. void SetDashedLineProc(DialogPtr dialog, short item)
  739. {
  740.     if (sDashLineProc == nil)
  741.         sDashLineProc = NewUserItemProc(DashedLineProc);
  742.         
  743.     SetUserProc(dialog, item, sDashLineProc);
  744. }
  745.  
  746.  
  747. //---------------------------------------------------------------
  748. //
  749. // SetDrawPictProc
  750. //
  751. //---------------------------------------------------------------
  752. void SetDrawPictProc(DialogPtr dialog, short item, PicHandle* pict)
  753. {
  754.     if (sDrawPictProc == nil)
  755.         sDrawPictProc = NewUserItemProc(DrawPictProc);
  756.     sPict = pict;
  757.         
  758.     SetUserProc(dialog, item, sDrawPictProc);
  759. }
  760.  
  761. #pragma mark -
  762.  
  763. //---------------------------------------------------------------
  764. //
  765. // SetDStr
  766. //
  767. //---------------------------------------------------------------
  768. void SetDStr(DialogPtr dialog, short item, const string& str)
  769. {
  770.     ASSERT(dialog != nil);
  771.     ASSERT(item >= 1 && item <= CountDITL(dialog));
  772.     
  773.     short    itemType;
  774.     Handle    itemHandle;
  775.     Rect    itemRect;
  776.  
  777.     GetDialogItem(dialog, item, &itemType, &itemHandle, &itemRect);
  778.     if (itemType > itemDisable)
  779.          itemType -= itemDisable;
  780.     ASSERT(itemType == statText || itemType == editText);
  781.     SetDialogItemText(itemHandle, StrToPStr(str));
  782. }
  783.  
  784.  
  785. //---------------------------------------------------------------
  786. //
  787. // FlashButton
  788. //
  789. //---------------------------------------------------------------
  790. void FlashButton(DialogPtr dialog, short item)
  791. {
  792.     ASSERT(dialog != nil);
  793.     ASSERT(item >= 1 && item <= CountDITL(dialog));
  794.     ASSERT(IsPushButton(dialog, item));
  795.     
  796.     long ticks;
  797.     
  798.     ControlHandle control = GetControl(dialog, item);
  799.     HiliteControl(control, kControlButtonPart);
  800.     Delay(8, &ticks);
  801.     HiliteControl(control, 0);
  802. }
  803.  
  804.